home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / strategy / xpat2-1.000 / xpat2-1 / xpat2-1.04 / src / commands.c < prev    next >
C/C++ Source or Header  |  1994-04-24  |  9KB  |  389 lines
  1. /*****************************************************************************/
  2. /*                                         */
  3. /*                                         */
  4. /*    X patience version 2 -- module commands.c                 */
  5. /*                                         */
  6. /*    Most of the entries for commands assignable to keys             */
  7. /*    written by Michael Bischoff                         */
  8. /*    see COPYRIGHT.xpat2 for Copyright details                 */
  9. /*                                         */
  10. /*                                         */
  11. /*****************************************************************************/
  12. #include "xpatgame.h"
  13. #include "version.h"
  14.  
  15. void change_rules(const char *new_rules_name) {
  16.     cmd_CancelSelection();
  17.     new_rules(new_rules_name, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);    /* std rules */
  18.     new_rules_notify();
  19.     newgame(-1L);            /* new game with random seed */
  20. }
  21.  
  22. void rq_LeavePat(void) {
  23.     if (game.finished || !game.n_moves)
  24.     cmd_LeavePat();
  25.     else
  26.     request_confirm(cmd_LeavePat, TXT_QUIT_CONFIRM);
  27. }
  28.  
  29. void rq_AnotherGame(void) {
  30.     if (game.finished || !game.n_moves)
  31.     cmd_AnotherGame();
  32.     else
  33.     request_confirm(cmd_AnotherGame, TXT_NEW_CONFIRM);
  34. }
  35.  
  36. /* unused, since this can be undone */
  37. void rq_RestartGame(void) {
  38.     request_confirm(cmd_RestartGame, TXT_RESTART_CONFIRM);
  39. }
  40.  
  41. void cmd_AnotherGame(void) {
  42.     if (!game.finished) {
  43.     play_sound("giveup");
  44.     }
  45.     newgame(-1L);
  46.     refresh_screen();
  47. }
  48.  
  49. void graphics_control(GraphicsControl cmd) {
  50.     Pileindex i;
  51.     switch (cmd) {
  52.     case Disable:
  53.     game.graphic = False;
  54.     for (i = 0; i < game.numpiles; ++i)
  55.         game.pile_changed[i] = PILE_UNCHANGED;
  56.     break;
  57.     case Enable:
  58.     game.graphic = True;
  59.     break;
  60.     case EnableAndRedraw:
  61.     game.graphic = True;
  62.     for (i = 0; i < game.numpiles; ++i)
  63.         if (game.pile_changed[i] != PILE_UNCHANGED) {
  64.         /* printf("pile_changed(%d) = %d\n", i, game.pile_changed[i]); */
  65.         draw_pileupdate(i, game.pile_changed[i]);
  66.         }
  67.     break;
  68.     }
  69. }
  70. void graphics_pile_control(GraphicsControl cmd, Pileindex pile) {
  71.     switch (cmd) {
  72.     case Disable:
  73.     game.disable[pile] = True;
  74.     break;
  75.     case Enable:
  76.     game.disable[pile] = False;
  77.     break;
  78.     case EnableAndRedraw:
  79.     game.disable[pile] = False;
  80.     draw_pileupdate(pile, 0);
  81.     break;
  82.     }
  83. }
  84.  
  85. void cmd_ReplayGame(void) {
  86.     int i, oldcheatcount = game.cheat_count;
  87.     int movenum = game.n_moves;
  88.     cmd_RestartGame();    /* with graphics! */
  89.     /* explicitly paint all the piles! */
  90.     for (i = 0; i < game.numpiles; ++i)
  91.     draw_pileupdate(i, 0);
  92.     while (game.n_moves < movenum) {
  93.     /* XSync(dpy, 0); */
  94.     redo_move();
  95.     }
  96.     game.cheat_count = oldcheatcount;
  97.     /* problem: we should ignore the following expose events! */
  98. }
  99.  
  100. void cmd_DropBookmark(void) {
  101.     game.bookmark = game.move_ptr;    /* easy, isn't it? */
  102.     show_message(TXT_BOOKMARK_SET);
  103. }
  104.  
  105. void jumpto_movenr(int move_ptr) {
  106.     int remgraphic = game.graphic;
  107.     if (move_ptr == game.move_ptr)
  108.     return;
  109.     assert(move_ptr <= game.stored_moves);
  110.     if (remgraphic)        /* graphic was on */
  111.     graphics_control(Disable);
  112.     if (move_ptr > game.move_ptr)    /* move forward */
  113.     while (move_ptr > game.move_ptr)
  114.         redo_move();
  115.     else
  116.     while (game.move_ptr > move_ptr)
  117.         undo_move();
  118.     if (remgraphic)
  119.     graphics_control(EnableAndRedraw);
  120. }
  121.  
  122. void cmd_RestartGame(void) {
  123.     jumpto_movenr(0);
  124. }
  125.  
  126. void cmd_GotoBookmark(void) {
  127.     jumpto_movenr(game.bookmark);
  128. }
  129.  
  130. void cmd_SaveGame(void) {
  131.     save_game(NULL);
  132. }
  133.  
  134. void cmd_ShowVersion(void) {
  135.     show_message("%s %s", TXT_VERSION, VERSION);
  136. }
  137.  
  138. static void infosub(char *buff, int n, int txtindex) {
  139.     switch (n) {
  140.     case 0:
  141.     strcpy(buff, xpat_messages[txtindex+0]);
  142.     break;
  143.     case 1:
  144.     strcpy(buff, xpat_messages[txtindex+1]);
  145.     break;
  146.     default:
  147.     sprintf(buff, xpat_messages[txtindex+2], n);
  148.     break;
  149.     }
  150. }
  151.  
  152. void cmd_ShowScore(void) {
  153.     char buf[256];
  154.     sprintf(buf, TXT_INFO1, game.seed, game.cheat_count);
  155.     strcat(buf, " ");
  156.     infosub(buf+strlen(buf), game.n_moves, TXT_MOVEBLOCK);
  157.     strcat(buf, " ");
  158.     if (rules.score) {
  159.     infosub(buf+strlen(buf), (*rules.score)(), TXT_SCOREBLOCK);
  160.     sprintf(buf+strlen(buf), " %d.", rules.maxscore);
  161.     } else
  162.     sprintf(buf+strlen(buf), TXT_NOSCORE);
  163.     show_message(buf);
  164. }
  165.  
  166. void cmd_Info(void) {
  167.     char buf[256];
  168.     int i;
  169.     buf[0] = '\0';
  170.     for (i = 0; i < 4; ++i) {
  171.     if (rules.paramstring[i]) {
  172.         infosub(buf+strlen(buf), rules.param[i]-game.counter[i], rules.paramstring[i]+1);
  173.         strcat(buf, "  ");
  174.     }
  175.     }
  176.     if (!(rules.variant & NODEAL) && CARDS_ON_DECK)
  177.     infosub(buf+strlen(buf), CARDS_ON_DECK, TXTI_CARDS+1);
  178.     show_message(buf);
  179. }
  180.  
  181. void cmd_DealCards(void) {
  182.     cmd_CancelSelection();
  183.     if (rules.variant & NODEAL) {
  184.     show_message(TXT_NODEAL);
  185.     return;
  186.     }
  187.     if (EMPTY(IDECK) && (rules.variant & DECK_SOURCE)) {
  188.     int i;
  189.     for (i = 0; i < 4; ++i)
  190.         if (rules.paramstring[i] == TXTI_FLIP) {
  191.         /* try a flip */
  192.         if (game.counter[i] == rules.param[i])
  193.             show_message(TXT_NOFLIPLEFT);
  194.         else {
  195.             store_move(give_new_cards());
  196.             show_message(TXT_FLIPPING);
  197.         }
  198.         return;
  199.         }
  200.     }
  201.     if (check_new_cards()) {
  202.     show_message(TXT_NEWCARDS);
  203.     store_move(give_new_cards());
  204.     } else
  205.     show_message(TXT_NONEWCARDS);
  206. }
  207.  
  208. void cmd_AllToStack(void) {
  209.     cmd_CancelSelection();
  210.     cmd_ToStack();
  211. }
  212.  
  213. void cmd_OneToStack(void) {
  214.     if (game.srcind < 0) {
  215.     game.srcind = UNSELECTED;
  216.     show_message(TXT_NOSOURCEPILE);
  217.     } else
  218.     cmd_ToStack();
  219. }
  220.  
  221. void cmd_ToStack(void) {
  222.     if (game.srcind < 0) {    /* all to stack */
  223.     game.srcind = UNSELECTED;
  224.     if (!all_to_stack())
  225.         show_message(TXT_NONE_TO_STACK);
  226.     else
  227.         show_message(TXT_MOVED_TO_STACK);
  228.     } else {
  229.     show_mark(False);
  230.     if (!move_to_stack(getpile(game.srcind)))
  231.         show_message(TXT_MOVENOTPOSSIBLE);
  232.     game.srcind = UNSELECTED;
  233.     }
  234. }
  235.  
  236. void cmd_UndoMove(void) {
  237.     cmd_CancelSelection();
  238.     switch (undo_move()) {
  239.     case 0:    show_message(TXT_NOUNDO);
  240.         break;
  241.     case 1:    show_message(TXT_UNDO);
  242.         break;
  243.     case 2:    show_message(TXT_UNDOCHEAT);
  244.         break;
  245.     }
  246. }
  247.  
  248. void cmd_RedoMove(void) {
  249.     cmd_CancelSelection();
  250.     switch (redo_move()) {
  251.     case 0:    show_message(TXT_NOREDO);
  252.         break;
  253.     case 1:    show_message(TXT_REDO);
  254.         break;
  255.     case 2:    show_message(TXT_REDOUNCHEAT);
  256.         break;
  257.     }
  258. }
  259.  
  260. static void hit_card(Pileindex pile, Cardindex card) {
  261.     static int srcpile;        /* temp. variable to hold getpile(srcind) */
  262.     
  263.     /* printf("hit_card(%d,%d) called\n", pile, card); */
  264.  
  265.     cmd_ResetHints();
  266.     if (game.srcind >= 0) {
  267.     Cardindex h;
  268.     h = game.srcind;
  269.     game.srcind = -1;
  270.     /* do move */
  271.     show_mark(False);
  272.     if (pile < 0) {
  273.         show_message("");
  274.         return;
  275.     }
  276.     if (pile != srcpile) {    /* else just unselect slot */
  277.         if (game.piletype[pile] == FacedownDeck && !(rules.variant & DECK_VISIBLE))
  278.         cmd_DealCards();
  279.         else {
  280.         if (move_valid(h, pile)) {
  281.             store_move(do_move(h, pile));
  282.             show_message("");
  283.         } else
  284.             show_message(TXT_INVALIDMOVE);
  285.         }
  286.     }
  287.     } else {        /* no mark to clear, set srcpile and game.srcind */
  288.     if (pile < 0) {
  289.         show_message("");
  290.         game.srcind = UNSELECTED;
  291.         return;
  292.     }
  293.     if (game.piletype[pile] == FacedownDeck && !(rules.variant & DECK_VISIBLE))
  294.         cmd_DealCards();
  295.     else {
  296.         game.srcind = card;
  297.         srcpile = pile;
  298.         if (card == -1)
  299.         show_message(TXT_BADSRC);
  300.         else {
  301.         show_message(TXT_SRCSELECTED);
  302.         show_mark(True);
  303.         }
  304.     }
  305.     }
  306. }
  307.  
  308. void cmd_CancelSelection(void) {
  309.     hit_card(-1, -1);
  310. }
  311. void cmd_RotateUp(void) {
  312.     int i;
  313.     hit_card(-1, -1);
  314.     for (i = 0; i < 4; ++i)
  315.     if (rules.paramstring[i] == TXTI_ROTATE) {
  316.         if (rules.param[i] > game.counter[i]) {
  317.         game.srcind = ROTATE_UP_SEL;
  318.         show_message(TXT_ROTUP);
  319.         return;
  320.         } else {
  321.         show_message(xpat_messages[TXTI_ROTATE+1]);
  322.         return;
  323.         }
  324.     }
  325.     show_message(xpat_messages[TXTI_ROTATE]);
  326. }
  327. void cmd_RotateDown(void) {
  328.     int i;
  329.     hit_card(-1, -1);
  330.     for (i = 0; i < 4; ++i)
  331.     if (rules.paramstring[i] == TXTI_ROTATE) {
  332.         if (rules.param[i] > game.counter[i]) {
  333.         game.srcind = ROTATE_DOWN_SEL;
  334.         show_message(TXT_ROTDN);
  335.         return;
  336.         } else {
  337.         show_message(xpat_messages[TXTI_ROTATE+1]);
  338.         return;
  339.         }
  340.     }
  341.     show_message(xpat_messages[TXTI_ROTATE]);
  342. }
  343.  
  344. void button_pressed(Pileindex i, Cardindex card, int button) {
  345.     /*printf("press %d %d %d called\n", i, card, button); */
  346.     if (i == -1) {    /* no pile hit => cancel */
  347.     cmd_CancelSelection();
  348.     return;
  349.     }
  350.     if (game.srcind == ROTATE_UP_SEL || game.srcind == ROTATE_DOWN_SEL) {
  351.     if (game.piletype[i] != Slot)
  352.         show_message(TXT_SLOTREQUIRED);
  353.     else if (!game.visible[card])
  354.         show_message(TXT_CARDNOTVISIBLE);
  355.     else
  356.         store_move(game.srcind == ROTATE_UP_SEL ? RotateUp(card) : RotateDown(card));
  357.     game.srcind = UNSELECTED;
  358.     return;
  359.     }
  360.  
  361.     switch (button) {
  362.     case 1:
  363.     cmd_CancelSelection();    /* calls cmd_ResetHints(); */
  364.     switch (game.piletype[i]) {
  365.     case FacedownDeck:
  366.         if (!(rules.variant & DECK_VISIBLE)) {
  367.         hit_card(i, 0);
  368.         return;
  369.         }
  370.         /* else fall through */
  371.     case FaceupDeck:
  372.     case Slot:
  373.     case Stack:
  374.     case Tmp:
  375.         {   Cardindex ind;
  376.         if ((ind = maxsequence(i, card)) < 0)
  377.             show_message(TXT_BADSRC);
  378.         else if (rules.automove ? !(*rules.automove)(ind) : !generic_automove(ind))
  379.             show_message(TXT_NOMOVE);
  380.         }
  381.         break;    /* no action */
  382.     }
  383.     break;
  384.     case 2:
  385.     hit_card(i, maxsequence(i, card));
  386.     break;
  387.     }
  388. }
  389.